26 research outputs found
Boosting Multi-Core Reachability Performance with Shared Hash Tables
This paper focuses on data structures for multi-core reachability, which is a
key component in model checking algorithms and other verification methods. A
cornerstone of an efficient solution is the storage of visited states. In
related work, static partitioning of the state space was combined with
thread-local storage and resulted in reasonable speedups, but left open whether
improvements are possible. In this paper, we present a scaling solution for
shared state storage which is based on a lockless hash table implementation.
The solution is specifically designed for the cache architecture of modern
CPUs. Because model checking algorithms impose loose requirements on the hash
table operations, their design can be streamlined substantially compared to
related work on lockless hash tables. Still, an implementation of the hash
table presented here has dozens of sensitive performance parameters (bucket
size, cache line size, data layout, probing sequence, etc.). We analyzed their
impact and compared the resulting speedups with related tools. Our
implementation outperforms two state-of-the-art multi-core model checkers (SPIN
and DiVinE) by a substantial margin, while placing fewer constraints on the
load balancing and search algorithms.Comment: preliminary repor
Fast equivalence checking of quantum circuits of Clifford gates
Checking whether two quantum circuits are equivalent is important for the
design and optimization of quantum-computer applications with real-world
devices. We consider quantum circuits consisting of Clifford gates, a
practically-relevant subset of all quantum operations which is large enough to
exhibit quantum features such as entanglement and forms the basis of, for
example, quantum-error correction and many quantum-network applications. We
present a deterministic algorithm that is based on a folklore mathematical
result and demonstrate that it is capable of outperforming previously
considered state-of-the-art method. In particular, given two Clifford circuits
as sequences of single- and two-qubit Clifford gates, the algorithm checks
their equivalence in time in the number of qubits and number
of elementary Clifford gates . Using the performant Stim simulator as
backend, our implementation checks equivalence of quantum circuits with 1000
qubits (and a circuit depth of 10.000 gates) in 22 seconds and circuits
with 100.000 qubits (depth 10) in 15 minutes, outperforming the existing
SAT-based and path-integral based approaches by orders of magnitude. This
approach shows that the correctness of application-relevant subsets of quantum
operations can be verified up to large circuits in practice
A Decision Diagram Operation for Reachability
Saturation is considered the state-of-the-art method for computing fixpoints
with decision diagrams. We present a relatively simple decision diagram
operation called REACH that also computes fixpoints. In contrast to saturation,
it does not require a partitioning of the transition relation. We give
sequential algorithms implementing the new operation for both binary and
multi-valued decision diagrams, and moreover provide parallel counterparts. We
implement these algorithms and experimentally compare their performance against
saturation on 692 model checking benchmarks in different languages. The results
show that the REACH operation often outperforms saturation, especially on
transition relations with low locality. In a comparison between parallelized
versions of REACH and saturation we find that REACH obtains comparable speedups
up to 16 cores, although falls behind saturation at 64 cores. Finally, in a
comparison with the state-of-the-art model checking tool ITS-tools we find that
REACH outperforms ITS-tools on 29% of models, suggesting that REACH can be
useful as a complementary method in an ensemble tool
Multi-core and/or Symbolic Model Checking
We review our progress in high-performance model checking. Our multi-core model checker is based on a scalable hash-table design and parallel random-walk traversal. Our symbolic model checker is based on Multiway Decision Diagrams and the saturation strategy. The LTSmin tool is based on the PINS architecture, decoupling model checking algorithms from the input specification language. Consequently, users can stay in their own specification language and postpone the choice between parallel or symbolic model checking. We support widely different specification languages including those of SPIN (Promela), mCRL2 and UPPAAL (timed automata). So far, multi-core and symbolic algorithms had very little in common, forcing the user in the end to make a wise trade-off between memory or speed. Recently, however, we designed a novel multi-core BDD package called Sylvan. This forms an excellent basis for scalable parallel symbolic model checking
LIMDD A Decision Diagram for Simulation of Quantum Computing Including Stabilizer States
Efficient methods for the representation and simulation of quantum states and
quantum operations are crucial for the optimization of quantum circuits.
Decision diagrams (DDs), a well-studied data structure originally used to
represent Boolean functions, have proven capable of capturing relevant aspects
of quantum systems, but their limits are not well understood. In this work, we
investigate and bridge the gap between existing DD-based structures and the
stabilizer formalism, an important tool for simulating quantum circuits in the
tractable regime. We first show that although DDs were suggested to succinctly
represent important quantum states, they actually require exponential space for
certain stabilizer states. To remedy this, we introduce a more powerful
decision diagram variant, called Local Invertible Map-DD (LIMDD). We prove that
the set of quantum states represented by poly-sized LIMDDs strictly contains
the union of stabilizer states and other decision diagram variants. Finally,
there exist circuits which LIMDDs can efficiently simulate, but which cannot be
efficiently simulated by two state-of-the-art simulation paradigms: the
Clifford + T simulator and Matrix-Product States. By uniting two successful
approaches, LIMDDs thus pave the way for fundamentally more powerful solutions
for simulation and analysis of quantum computing
LTSmin: high-performance language-independent model checking
In recent years, the LTSmin model checker has been extended with support for several new modelling languages, including probabilistic (Mapa) and timed systems (Uppaal). Also, connecting additional language front-ends or ad-hoc state-space generators to LTSmin was simplified using custom C-code. From symbolic and distributed reachability analysis and minimisation, LTSmin’s functionality has developed into a model checker with multi-core algorithms for on-the-fly LTL checking with partial-order reduction, and multi-core symbolic checking for the modal μ calculus, based on the multi-core decision diagram package Sylvan.\ud
In LTSmin, the modelling languages and the model checking algorithms are connected through a Partitioned Next-State Interface (Pins), that allows to abstract away from language details in the implementation of the analysis algorithms and on-the-fly optimisations. In the current paper, we present an overview of the toolset and its recent changes, and we demonstrate its performance and versatility in two case studies
Variations on Multi-Core Nested Depth-First Search
Recently, two new parallel algorithms for on-the-fly model checking of LTL
properties were presented at the same conference: Automated Technology for
Verification and Analysis, 2011. Both approaches extend Swarmed NDFS, which
runs several sequential NDFS instances in parallel. While parallel random
search already speeds up detection of bugs, the workers must share some global
information in order to speed up full verification of correct models. The two
algorithms differ considerably in the global information shared between
workers, and in the way they synchronize.
Here, we provide a thorough experimental comparison between the two
algorithms, by measuring the runtime of their implementations on a multi-core
machine. Both algorithms were implemented in the same framework of the model
checker LTSmin, using similar optimizations, and have been subjected to the
full BEEM model database.
Because both algorithms have complementary advantages, we constructed an
algorithm that combines both ideas. This combination clearly has an improved
speedup. We also compare the results with the alternative parallel algorithm
for accepting cycle detection OWCTY-MAP. Finally, we study a simple statistical
model for input models that do contain accepting cycles. The goal is to
distinguish the speedup due to parallel random search from the speedup that can
be attributed to clever work sharing schemes.Comment: In Proceedings PDMC 2011, arXiv:1111.006